home *** CD-ROM | disk | FTP | other *** search
/ Aminet 35 / Aminet 35 (2000)(Schatztruhe)[!][Feb 2000].iso / Aminet / game / shoot / ADescentSrc.lha / descent / main / bm.c < prev    next >
C/C++ Source or Header  |  1998-09-26  |  17KB  |  512 lines
  1. /*
  2. THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
  3. SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
  4. END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
  5. ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
  6. IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
  7. SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
  8. FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
  9. CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  10. AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.  
  11. COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  12. */
  13. /*
  14.  * $Source: /usr/CVS/descent/main/bm.c,v $
  15.  * $Revision: 1.3 $
  16.  * $Author: nobody $
  17.  * $Date: 1998/09/26 15:09:06 $
  18.  *
  19.  * Bitmap and palette loading functions.
  20.  *
  21.  * $Log: bm.c,v $
  22.  * Revision 1.3  1998/09/26 15:09:06  nobody
  23.  * Added Warp3D support
  24.  *
  25.  * Revision 1.2  1998/04/09 16:16:07  tfrieden
  26.  * Removed old log messages and bogus mymalloc
  27.  *
  28.  * Revision 1.1.1.1  1998/03/03 15:12:11  nobody
  29.  * reimport after crash from backup
  30.  *
  31.  * Revision 1.1.1.1  1998/02/13  20:20:43  hfrieden
  32.  * Initial Import
  33.  */
  34.  
  35. #pragma off (unreferenced)
  36. static char rcsid[] = "$Id: bm.c,v 1.3 1998/09/26 15:09:06 nobody Exp $";
  37. #pragma on (unreferenced)
  38.  
  39. #include <stdio.h>
  40. #include <stdlib.h>
  41.  
  42. #include "types.h"
  43. #include "inferno.h"
  44. #include "gr.h"
  45. #include "3d.h"
  46. #include "bm.h"
  47. #include "mem.h"
  48. #include "mono.h"
  49. #include "error.h"
  50. #include "object.h"
  51. #include "vclip.h"
  52. #include "effects.h"
  53. #include "polyobj.h"
  54. #include "wall.h"
  55. #include "textures.h"
  56. #include "game.h"
  57. #include "multi.h"
  58. #include "iff.h"
  59. #include "cfile.h"
  60. #include "hostage.h"
  61. #include "powerup.h"
  62. #include "sounds.h"
  63. #include "piggy.h"
  64. #include "aistruct.h"
  65. #include "robot.h"
  66. #include "weapon.h"
  67. #include "gauges.h"
  68. #include "player.h"
  69. #include "fuelcen.h"
  70. #include "endlevel.h"
  71. #include "cntrlcen.h"
  72. #include "byteswap.h"
  73. #include "fileutil.h"
  74.  
  75. ubyte Sounds[MAX_SOUNDS];
  76. ubyte AltSounds[MAX_SOUNDS];
  77.  
  78. extern int Num_tmaps;
  79.  
  80. int Num_total_object_types;
  81.  
  82. byte    ObjType[MAX_OBJTYPE];
  83. byte    ObjId[MAX_OBJTYPE];
  84. fix ObjStrength[MAX_OBJTYPE];
  85.  
  86. //for each model, a model number for dying & dead variants, or -1 if none
  87. int Dying_modelnums[MAX_POLYGON_MODELS];
  88. int Dead_modelnums[MAX_POLYGON_MODELS];
  89.  
  90. //right now there's only one player ship, but we can have another by 
  91. //adding an array and setting the pointer to the active ship.
  92. player_ship only_player_ship,*Player_ship=&only_player_ship;
  93.  
  94. //----------------- Miscellaneous bitmap pointers ---------------
  95. int                 Num_cockpits = 0;
  96. bitmap_index        cockpit_bitmap[N_COCKPIT_BITMAPS];
  97.  
  98. //---------------- Variables for wall textures ------------------
  99. int                     Num_tmaps;
  100. tmap_info           TmapInfo[MAX_TEXTURES];
  101.  
  102. //---------------- Variables for object textures ----------------
  103.  
  104. int                 First_multi_bitmap_num=-1;
  105.  
  106. bitmap_index        ObjBitmaps[MAX_OBJ_BITMAPS];
  107. ushort              ObjBitmapPtrs[MAX_OBJ_BITMAPS];     // These point back into ObjBitmaps, since some are used twice.
  108.  
  109. // swap_vclip bytes swaps the elements of a vclip structure
  110. void swap_vclip(vclip *vc)
  111. {
  112.     int i, j;
  113.     
  114.     vc->play_time = (fix)swapint((int)vc->play_time);
  115.     vc->num_frames = swapint(vc->num_frames);
  116.     vc->frame_time = (fix)swapint((int)vc->frame_time);
  117.     vc->flags = swapint(vc->flags);
  118.     vc->sound_num = swapshort(vc->sound_num);
  119.     vc->light_value = (fix)swapint((int)vc->light_value);
  120.     for (j = 0; j < VCLIP_MAX_FRAMES; j++)
  121.         vc->frames[j].index = swapshort(vc->frames[j].index);
  122. }
  123.  
  124. void read_tmap_info(CFILE *fp)
  125. {
  126.     int i;
  127.     
  128.     for (i = 0; i < MAX_TEXTURES; i++) {
  129.         cfread(TmapInfo[i].filename, 13, 1, fp);
  130.         TmapInfo[i].flags = read_byte(fp);
  131.         TmapInfo[i].lighting = read_fix_swap(fp);
  132.         TmapInfo[i].damage = read_fix_swap(fp);
  133.         TmapInfo[i].eclip_num = read_int_swap(fp);
  134.     }
  135. }
  136.  
  137. void read_vclip_info(CFILE *fp)
  138. {
  139.     int i, j;
  140.     
  141.     for (i = 0; i < VCLIP_MAXNUM; i++) {
  142.         Vclip[i].play_time = read_fix_swap(fp);
  143.         Vclip[i].num_frames = read_int_swap(fp);
  144.         Vclip[i].frame_time = read_fix_swap(fp);
  145.         Vclip[i].flags = read_int_swap(fp);
  146.         Vclip[i].sound_num = read_short_swap(fp);
  147.         for (j = 0; j < VCLIP_MAX_FRAMES; j++)
  148.             Vclip[i].frames[j].index = read_short_swap(fp);
  149.         Vclip[i].light_value = read_fix_swap(fp);
  150.     }
  151. }
  152.  
  153. void read_effect_info(CFILE *fp)
  154. {
  155.     int i, j;
  156.  
  157.     for (i = 0; i < MAX_EFFECTS; i++) {
  158.         Effects[i].vc.play_time = read_fix_swap(fp);
  159.         Effects[i].vc.num_frames = read_int_swap(fp);
  160.         Effects[i].vc.frame_time = read_fix_swap(fp);
  161.         Effects[i].vc.flags = read_int_swap(fp);
  162.         Effects[i].vc.sound_num = read_short_swap(fp);
  163.         for (j = 0; j < VCLIP_MAX_FRAMES; j++)
  164.             Effects[i].vc.frames[j].index = read_short_swap(fp);
  165.         Effects[i].vc.light_value = read_fix_swap(fp);
  166.         Effects[i].time_left = read_fix_swap(fp);
  167.         Effects[i].frame_count = read_int_swap(fp);
  168.         Effects[i].changing_wall_texture = read_short_swap(fp);
  169.         Effects[i].changing_object_texture = read_short_swap(fp);
  170.         Effects[i].flags = read_int_swap(fp);
  171.         Effects[i].crit_clip = read_int_swap(fp);
  172.         Effects[i].dest_bm_num = read_int_swap(fp);
  173.         Effects[i].dest_vclip = read_int_swap(fp);
  174.         Effects[i].dest_eclip = read_int_swap(fp);
  175.         Effects[i].dest_size = read_fix_swap(fp);
  176.         Effects[i].sound_num = read_int_swap(fp);
  177.         Effects[i].segnum = read_int_swap(fp);
  178.         Effects[i].sidenum = read_int_swap(fp);
  179.     }
  180. }
  181.  
  182. void read_wallanim_info(CFILE *fp)
  183. {
  184.     int i, j;
  185.     
  186.     for (i = 0; i < MAX_WALL_ANIMS; i++) {
  187.         WallAnims[i].play_time = read_fix_swap(fp);;
  188.         WallAnims[i].num_frames = read_short_swap(fp);;
  189.         for (j = 0; j < MAX_CLIP_FRAMES; j++)
  190.             WallAnims[i].frames[j] = read_short_swap(fp);
  191.         WallAnims[i].open_sound = read_short_swap(fp);
  192.         WallAnims[i].close_sound = read_short_swap(fp);
  193.         WallAnims[i].flags = read_short_swap(fp);
  194.         cfread(WallAnims[i].filename, 13, 1, fp);
  195.         WallAnims[i].pad = read_byte(fp);
  196.     }       
  197. }
  198.  
  199. void read_robot_info(CFILE *fp)
  200. {
  201.     int i, j, k;
  202.     
  203.     for (i = 0; i < MAX_ROBOT_TYPES; i++) {
  204.         Robot_info[i].model_num = read_int_swap(fp);
  205.         Robot_info[i].n_guns = read_int_swap(fp);
  206.         for (j = 0; j < MAX_GUNS; j++) {
  207.             Robot_info[i].gun_points[j].x = read_fix_swap(fp);
  208.             Robot_info[i].gun_points[j].y = read_fix_swap(fp);
  209.             Robot_info[i].gun_points[j].z = read_fix_swap(fp);
  210.         }
  211.         for (j = 0; j < MAX_GUNS; j++)
  212.             Robot_info[i].gun_submodels[j] = read_byte(fp);
  213.         Robot_info[i].exp1_vclip_num = read_short_swap(fp);
  214.         Robot_info[i].exp1_sound_num = read_short_swap(fp);
  215.         Robot_info[i].exp2_vclip_num = read_short_swap(fp);
  216.         Robot_info[i].exp2_sound_num = read_short_swap(fp);
  217.         Robot_info[i].weapon_type = read_short_swap(fp);
  218.         Robot_info[i].contains_id = read_byte(fp);
  219.         Robot_info[i].contains_count = read_byte(fp);
  220.         Robot_info[i].contains_prob = read_byte(fp);
  221.         Robot_info[i].contains_type = read_byte(fp);
  222.         Robot_info[i].score_value = read_int_swap(fp);
  223.         Robot_info[i].lighting = read_fix_swap(fp);
  224.         Robot_info[i].strength = read_fix_swap(fp);
  225.         Robot_info[i].mass = read_fix_swap(fp);
  226.         Robot_info[i].drag = read_fix_swap(fp);
  227.         for (j = 0; j < NDL; j++)
  228.             Robot_info[i].field_of_view[j] = read_fix_swap(fp);
  229.         for (j = 0; j < NDL; j++)
  230.             Robot_info[i].firing_wait[j] = read_fix_swap(fp);
  231.         for (j = 0; j < NDL; j++)
  232.             Robot_info[i].turn_time[j] = read_fix_swap(fp);
  233.         for (j = 0; j < NDL; j++)
  234.             Robot_info[i].fire_power[j] = read_fix_swap(fp);
  235.         for (j = 0; j < NDL; j++)
  236.             Robot_info[i].shield[j] = read_fix_swap(fp);
  237.         for (j = 0; j < NDL; j++)
  238.             Robot_info[i].max_speed[j] = read_fix_swap(fp);
  239.         for (j = 0; j < NDL; j++)
  240.             Robot_info[i].circle_distance[j] = read_fix_swap(fp);
  241.         for (j = 0; j < NDL; j++)
  242.             cfread(&(Robot_info[i].rapidfire_count[j]), sizeof(byte), 1, fp);
  243.         for (j = 0; j < NDL; j++)
  244.             cfread(&(Robot_info[i].evade_speed[j]), sizeof(byte), 1, fp);
  245.         Robot_info[i].cloak_type = read_byte(fp);
  246.         Robot_info[i].attack_type = read_byte(fp);
  247.         Robot_info[i].boss_flag = read_byte(fp);
  248.         Robot_info[i].see_sound = read_byte(fp);
  249.         Robot_info[i].attack_sound = read_byte(fp);
  250.         Robot_info[i].claw_sound = read_byte(fp);
  251.  
  252.         for (j = 0; j < MAX_GUNS + 1; j++) {
  253.             for (k = 0; k < N_ANIM_STATES; k++) {
  254.                 Robot_info[i].anim_states[j][k].n_joints = read_short_swap(fp);
  255.                 Robot_info[i].anim_states[j][k].offset = read_short_swap(fp);
  256.             }
  257.         }
  258.  
  259.         Robot_info[i].always_0xabcd = read_int_swap(fp);
  260.     }
  261. }
  262.  
  263. void read_robot_joints_info(CFILE *fp)
  264. {
  265.     int i;
  266.  
  267.     for (i = 0; i < MAX_ROBOT_JOINTS; i++) {
  268.         Robot_joints[i].jointnum = read_short_swap(fp);
  269.         Robot_joints[i].angles.p = read_short_swap(fp);
  270.         Robot_joints[i].angles.b = read_short_swap(fp);
  271.         Robot_joints[i].angles.h = read_short_swap(fp);
  272.     }
  273. }
  274.  
  275. void read_weapon_info(CFILE *fp)
  276. {
  277.     int i, j;
  278.     
  279.     for (i = 0; i < MAX_WEAPON_TYPES; i++) {
  280.         Weapon_info[i].render_type = read_byte(fp);
  281.         Weapon_info[i].model_num = read_byte(fp);
  282.         Weapon_info[i].model_num_inner = read_byte(fp);
  283.         Weapon_info[i].persistent = read_byte(fp);
  284.         Weapon_info[i].flash_vclip = read_byte(fp);
  285.         Weapon_info[i].flash_sound = read_short_swap(fp);       
  286.         Weapon_info[i].robot_hit_vclip = read_byte(fp);
  287.         Weapon_info[i].robot_hit_sound = read_short_swap(fp);       
  288.         Weapon_info[i].wall_hit_vclip = read_byte(fp);
  289.         Weapon_info[i].wall_hit_sound = read_short_swap(fp);        
  290.         Weapon_info[i].fire_count = read_byte(fp);
  291.         Weapon_info[i].ammo_usage = read_byte(fp);
  292.         Weapon_info[i].weapon_vclip = read_byte(fp);
  293.         Weapon_info[i].destroyable = read_byte(fp);
  294.         Weapon_info[i].matter = read_byte(fp);
  295.         Weapon_info[i].bounce = read_byte(fp);
  296.         Weapon_info[i].homing_flag = read_byte(fp);
  297.         Weapon_info[i].dum1 = read_byte(fp);
  298.         Weapon_info[i].dum2 = read_byte(fp);
  299.         Weapon_info[i].dum3 = read_byte(fp);
  300.         Weapon_info[i].energy_usage = read_fix_swap(fp);
  301.         Weapon_info[i].fire_wait = read_fix_swap(fp);
  302.         Weapon_info[i].bitmap.index = read_short_swap(fp);  // bitmap_index = short
  303.         Weapon_info[i].blob_size = read_fix_swap(fp);
  304.         Weapon_info[i].flash_size = read_fix_swap(fp);
  305.         Weapon_info[i].impact_size = read_fix_swap(fp);
  306.         for (j = 0; j < NDL; j++)
  307.             Weapon_info[i].strength[j] = read_fix_swap(fp);
  308.         for (j = 0; j < NDL; j++)
  309.             Weapon_info[i].speed[j] = read_fix_swap(fp);
  310.         Weapon_info[i].mass = read_fix_swap(fp);
  311.         Weapon_info[i].drag = read_fix_swap(fp);
  312.         Weapon_info[i].thrust = read_fix_swap(fp);
  313.  
  314.         Weapon_info[i].po_len_to_width_ratio = read_fix_swap(fp);
  315.         Weapon_info[i].light = read_fix_swap(fp);
  316.         Weapon_info[i].lifetime = read_fix_swap(fp);
  317.         Weapon_info[i].damage_radius = read_fix_swap(fp);
  318.         Weapon_info[i].picture.index = read_short_swap(fp);     // bitmap_index is a short
  319.     }
  320. }
  321.  
  322. void read_powerup_info(CFILE *fp)
  323. {
  324.     int i;
  325.     
  326.     for (i = 0; i < MAX_POWERUP_TYPES; i++) {
  327.         Powerup_info[i].vclip_num = read_int_swap(fp);
  328.         Powerup_info[i].hit_sound = read_int_swap(fp);
  329.         Powerup_info[i].size = read_fix_swap(fp);
  330.         Powerup_info[i].light = read_fix_swap(fp);
  331.     }
  332. }
  333.  
  334. void read_polygon_models(CFILE *fp)
  335. {
  336.     int i, j;
  337.  
  338.     //Polygon_models = (polymodel *)mymalloc(sizeof(polymodel) * N_polygon_models);
  339.     if (Polygon_models == NULL)
  340.         Error("Cannot allocate space for Polygon_models!!");
  341.     for (i = 0; i < N_polygon_models; i++) {
  342.         Polygon_models[i].n_models = read_int_swap(fp);
  343.         Polygon_models[i].model_data_size = read_int_swap(fp);
  344.         Polygon_models[i].model_data = (ubyte *)read_int_swap(fp);
  345.         for (j = 0; j < MAX_SUBMODELS; j++)
  346.             Polygon_models[i].submodel_ptrs[j] = read_int_swap(fp);
  347.         for (j = 0; j < MAX_SUBMODELS; j++) {
  348.             Polygon_models[i].submodel_offsets[j].x = read_fix_swap(fp);
  349.             Polygon_models[i].submodel_offsets[j].y = read_fix_swap(fp);
  350.             Polygon_models[i].submodel_offsets[j].z = read_fix_swap(fp);
  351.         }
  352.         for (j = 0; j < MAX_SUBMODELS; j++) {
  353.             Polygon_models[i].submodel_norms[j].x = read_fix_swap(fp);
  354.             Polygon_models[i].submodel_norms[j].y = read_fix_swap(fp);
  355.             Polygon_models[i].submodel_norms[j].z = read_fix_swap(fp);
  356.         }
  357.         for (j = 0; j < MAX_SUBMODELS; j++) {
  358.             Polygon_models[i].submodel_pnts[j].x = read_fix_swap(fp);
  359.             Polygon_models[i].submodel_pnts[j].y = read_fix_swap(fp);
  360.             Polygon_models[i].submodel_pnts[j].z = read_fix_swap(fp);
  361.         }
  362.         for (j = 0; j < MAX_SUBMODELS; j++)
  363.             Polygon_models[i].submodel_rads[j] = read_fix_swap(fp);
  364.         for (j = 0; j < MAX_SUBMODELS; j++)
  365.             Polygon_models[i].submodel_parents[j] = read_byte(fp);
  366.         for (j = 0; j < MAX_SUBMODELS; j++) {
  367.             Polygon_models[i].submodel_mins[j].x = read_fix_swap(fp);
  368.             Polygon_models[i].submodel_mins[j].y = read_fix_swap(fp);
  369.             Polygon_models[i].submodel_mins[j].z = read_fix_swap(fp);
  370.         }
  371.         for (j = 0; j < MAX_SUBMODELS; j++) {
  372.             Polygon_models[i].submodel_maxs[j].x = read_fix_swap(fp);
  373.             Polygon_models[i].submodel_maxs[j].y = read_fix_swap(fp);
  374.             Polygon_models[i].submodel_maxs[j].z = read_fix_swap(fp);
  375.         }
  376.         Polygon_models[i].mins.x = read_fix_swap(fp);
  377.         Polygon_models[i].mins.y = read_fix_swap(fp);
  378.         Polygon_models[i].mins.z = read_fix_swap(fp);
  379.         Polygon_models[i].maxs.x = read_fix_swap(fp);
  380.         Polygon_models[i].maxs.y = read_fix_swap(fp);
  381.         Polygon_models[i].maxs.z = read_fix_swap(fp);
  382.         Polygon_models[i].rad = read_fix_swap(fp);      
  383.         Polygon_models[i].n_textures = read_byte(fp);
  384.         Polygon_models[i].first_texture = read_short_swap(fp);
  385.         Polygon_models[i].simpler_model = read_byte(fp);
  386.     }
  387. }
  388.  
  389. void read_player_ship(CFILE *fp)
  390. {
  391.     int i;
  392.     only_player_ship.model_num = read_int_swap(fp);
  393.     only_player_ship.expl_vclip_num = read_int_swap(fp);
  394.     only_player_ship.mass = read_fix_swap(fp);
  395.     only_player_ship.drag = read_fix_swap(fp);
  396.     only_player_ship.max_thrust = read_fix_swap(fp);
  397.     only_player_ship.reverse_thrust = read_fix_swap(fp);
  398.     only_player_ship.brakes = read_fix_swap(fp);
  399.     only_player_ship.wiggle = read_fix_swap(fp);
  400.     only_player_ship.max_rotthrust = read_fix_swap(fp);
  401.     for (i = 0; i < N_PLAYER_GUNS; i++) {
  402.         only_player_ship.gun_points[i].x = read_fix_swap(fp);
  403.         only_player_ship.gun_points[i].y = read_fix_swap(fp);
  404.         only_player_ship.gun_points[i].z = read_fix_swap(fp);
  405.     }
  406. }
  407.  
  408. //-----------------------------------------------------------------
  409. // Initializes all bitmaps from BITMAPS.TBL file.
  410. int bm_init()
  411. {
  412.     init_polygon_models();
  413.     piggy_init();               // This calls bm_read_all
  414.     piggy_read_sounds();
  415.     return 0;
  416. }
  417.  
  418. void bm_read_all(CFILE * fp)
  419. {
  420.     int i, j, k;
  421.  
  422. //  bitmap_index is a short
  423.  
  424.     NumTextures = read_int_swap(fp);
  425.     Num_tmaps = NumTextures;
  426.     for (i = 0; i < MAX_TEXTURES; i++)
  427.         Textures[i].index = read_short_swap(fp);
  428.         
  429.     read_tmap_info(fp);
  430.     
  431.     cfread( Sounds, sizeof(ubyte), MAX_SOUNDS, fp );
  432.     cfread( AltSounds, sizeof(ubyte), MAX_SOUNDS, fp );
  433.  
  434.     Num_vclips = read_int_swap(fp);
  435.     read_vclip_info(fp);
  436.  
  437.     Num_effects = read_int_swap(fp);
  438.     read_effect_info(fp);
  439.  
  440.     Num_wall_anims = read_int_swap(fp);
  441.     read_wallanim_info(fp);
  442.  
  443.     N_robot_types = read_int_swap(fp);  
  444.     read_robot_info(fp);
  445.  
  446.     N_robot_joints = read_int_swap(fp);
  447.     read_robot_joints_info(fp);
  448.  
  449.     N_weapon_types = read_int_swap(fp);
  450.     read_weapon_info(fp);
  451.  
  452.     N_powerup_types = read_int_swap(fp);
  453.     read_powerup_info(fp);
  454.  
  455.     N_polygon_models = read_int_swap(fp);   
  456.     read_polygon_models(fp);
  457.     
  458.     for (i = 0; i < N_polygon_models; i++) {
  459.         Polygon_models[i].model_data = malloc(Polygon_models[i].model_data_size);
  460.         Assert(Polygon_models[i].model_data != NULL);
  461.         cfread(Polygon_models[i].model_data, sizeof(ubyte), Polygon_models[i].model_data_size, fp);
  462.         swap_polygon_model_data(Polygon_models[i].model_data);
  463.     }
  464.     
  465.     for (i = 0; i < MAX_GAUGE_BMS; i++)
  466.         Gauges[i].index = read_short_swap(fp);
  467.  
  468.     for (i = 0; i < MAX_POLYGON_MODELS; i++)
  469.         Dying_modelnums[i] = read_int_swap(fp);
  470.     for (i = 0; i < MAX_POLYGON_MODELS; i++)
  471.         Dead_modelnums[i] = read_int_swap(fp);
  472.  
  473.     for (i = 0; i < MAX_OBJ_BITMAPS; i++)
  474.         ObjBitmaps[i].index = read_short_swap(fp);
  475.     for (i = 0; i < MAX_OBJ_BITMAPS; i++)
  476.         ObjBitmapPtrs[i] = read_short_swap(fp);
  477.  
  478.     read_player_ship(fp);
  479.  
  480.     Num_cockpits = read_int_swap(fp);
  481.     for (i = 0; i < N_COCKPIT_BITMAPS; i++)
  482.         cockpit_bitmap[i].index = read_short_swap(fp);
  483.  
  484.     cfread( Sounds, sizeof(ubyte), MAX_SOUNDS, fp );
  485.     cfread( AltSounds, sizeof(ubyte), MAX_SOUNDS, fp );
  486.  
  487.     Num_total_object_types = read_int_swap(fp);
  488.     cfread( ObjType, sizeof(byte), MAX_OBJTYPE, fp );
  489.     cfread( ObjId, sizeof(byte), MAX_OBJTYPE, fp );
  490.     for (i = 0; i < MAX_OBJTYPE; i++)
  491.         ObjStrength[i] = read_fix_swap(fp);
  492.  
  493.     First_multi_bitmap_num = read_int_swap(fp);
  494.     N_controlcen_guns = read_int_swap(fp);
  495.  
  496.     for (i = 0; i < MAX_CONTROLCEN_GUNS; i++) {
  497.         controlcen_gun_points[i].x = read_fix_swap(fp);
  498.         controlcen_gun_points[i].y = read_fix_swap(fp);
  499.         controlcen_gun_points[i].z = read_fix_swap(fp);
  500.     }
  501.     for (i = 0; i < MAX_CONTROLCEN_GUNS; i++) {
  502.         controlcen_gun_dirs[i].x = read_fix_swap(fp);
  503.         controlcen_gun_dirs[i].y = read_fix_swap(fp);
  504.         controlcen_gun_dirs[i].z = read_fix_swap(fp);
  505.     }
  506.     
  507.     exit_modelnum = read_int_swap(fp);  
  508.     destroyed_exit_modelnum = read_int_swap(fp);
  509. }
  510.  
  511.  
  512.